package com.kinglone.common.utils;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

/**	文件处理
*  创建人：FH Q313596790
 * 创建时间：2014年12月23日
 */
public class FileUtil {

	public static Logger logger = LogManager.getLogger(FileUtil.class);
	
	/**获取文件大小 返回 KB 保留3位小数  没有文件时返回0
	 * @param filepath 文件完整路径，包括文件名
	 * @return
	 */
	public static Double getFilesize(String filepath){
		File backupath = new File(filepath);
		return Double.valueOf(backupath.length())/1000.000;
	}
	
	/**
	 * 创建目录
	 * @param destDirName
	 * @return 
	 */
	public static Boolean createDir(String destDirName) {
		try{
		File dir = new File(destDirName);
		if(!dir.getParentFile().exists()){				//判断有没有父路径，就是判断文件整个路径是否存在
			return dir.getParentFile().mkdirs();		//不存在就全部创建
		}
		return true;
		}catch(Exception e){
			logger.error(e);
			return false;	
		}
	}
	
	public static Boolean createAllDir(String destDirName) {
		try{
			File dir = new File(destDirName);
			if(!dir.exists()){				//判断有没有路径，就是判断文件整个路径是否存在
				return dir.mkdirs();		//不存在就全部创建
			}
			return true;
		}catch(Exception e){
			logger.error(e);
			return false;	
		}
	}

	/**
	 * 删除文件
	 * @param filePathAndName
	 *            String 文件路径及名称 如c:/fqf.txt
	 * @param filePathAndName
	 *            String
	 * @return boolean
	 */
	public static void delFile(String filePathAndName) {
		try {
			String filePath = filePathAndName;
			filePath = filePath.toString();
			File myDelFile = new File(filePath);
			myDelFile.delete();
		} catch (Exception e) {
			logger.error(e);
			System.out.println("删除文件操作出错");
			e.printStackTrace();
		}
	}

	/**
	 * 删除文件夹
	 * @param filePath
	 */
	public static void delFileDir(String filePath) {
		try {
			File dir = new File(filePath);
			deleteDir(dir);
		} catch (Exception e) {
			logger.error(e);
			System.out.println("删除文件夹及子项操作出错");
			e.printStackTrace();
		}
	}
	
	public static boolean deleteDir(File dir) {
        if(dir.isDirectory()) {
            String[] children = dir.list();
            //递归删除目录中的子目录下
            for (int i=0; i<children.length; i++) {
                boolean success = deleteDir(new File(dir, children[i]));
                if (!success) {
                    return false;
                }
            }
        }
        //目录此时为空，可以删除
        return dir.delete();
    }

	/**
	 * 读取到字节数组0
	 * @param filePath //路径
	 * @throws IOException
	 */
	@SuppressWarnings("resource")
	public static byte[] getContent(String filePath) throws IOException {
		File file = new File(filePath);
		long fileSize = file.length();
		if (fileSize > Integer.MAX_VALUE) {
			System.out.println("file too big...");
			return null;
		}
		FileInputStream fi = new FileInputStream(file);
		byte[] buffer = new byte[(int) fileSize];
		int offset = 0;
		int numRead = 0;
		while (offset < buffer.length
				&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
			offset += numRead;
		}
		// 确保所有数据均被读取
		if (offset != buffer.length) {
			throw new IOException("Could not completely read file " + file.getName());
		}
		fi.close();
		return buffer;
	}

	/**
	 * 读取到字节数组1
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray(String filePath) throws IOException {

		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}
		ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
		BufferedInputStream in = null;
		try {
			in = new BufferedInputStream(new FileInputStream(f));
			int buf_size = 1024;
			byte[] buffer = new byte[buf_size];
			int len = 0;
			while (-1 != (len = in.read(buffer, 0, buf_size))) {
				bos.write(buffer, 0, len);
			}
			return bos.toByteArray();
		} catch (IOException e) {
			logger.error(e);
			e.printStackTrace();
			throw e;
		} finally {
			try {
				in.close();
			} catch (IOException e) {
				logger.error(e);
				e.printStackTrace();
			}
			bos.close();
		}
	}

	/**
	 * 读取到字节数组2
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray2(String filePath) throws IOException {
		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}
		FileChannel channel = null;
		FileInputStream fs = null;
		try {
			fs = new FileInputStream(f);
			channel = fs.getChannel();
			ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size());
			while ((channel.read(byteBuffer)) > 0) {
				// do nothing
				// System.out.println("reading");
			}
			return byteBuffer.array();
		} catch (IOException e) {
			logger.error(e);
			e.printStackTrace();
			throw e;
		} finally {
			try {
				channel.close();
			} catch (IOException e) {
				logger.error(e);
				e.printStackTrace();
			}
			try {
				fs.close();
			} catch (IOException e) {
				logger.error(e);
				e.printStackTrace();
			}
		}
	}

	/**
	 * Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray3(String filePath) throws IOException {

		FileChannel fc = null;
		RandomAccessFile rf = null;
		try {
			rf = new RandomAccessFile(filePath, "r");
			fc = rf.getChannel();
			MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0,
					fc.size()).load();
			//System.out.println(byteBuffer.isLoaded());
			byte[] result = new byte[(int) fc.size()];
			if (byteBuffer.remaining() > 0) {
				// System.out.println("remain");
				byteBuffer.get(result, 0, byteBuffer.remaining());
			}
			return result;
		} catch (IOException e) {
			logger.error(e);
			e.printStackTrace();
			throw e;
		} finally {
			try {
				rf.close();
				fc.close();
			} catch (IOException e) {
				logger.error(e);
				e.printStackTrace();
			}
		}
	}
	
	/**
	 * 文件拷贝.
	 * @param sourceFileName 源文件名
	 * @param tarFileName 目标文件名
	 * @return 是否成功
	 */
	public static void fileCopy(String sourceFileName, String tarFileName) {
		int byteread = 0;
		InputStream inStream = null;
		FileOutputStream fs = null;
		try {
			inStream = new FileInputStream(sourceFileName);
			fs = new FileOutputStream(tarFileName);
			byte[] buffer = new byte[1444];
			while ((byteread = inStream.read(buffer)) != -1) {
				fs.write(buffer, 0, byteread);
			}
			
			inStream.close();
			fs.close();
		} catch (Exception e) {
			logger.error(e);
			
			try {
				if(inStream != null){inStream.close();}
				if(fs != null){fs.close();}
			} catch (Exception e2) {
				logger.error(e2);
				throw new RuntimeException();
			}
			throw new RuntimeException();
		}
	}
	
	/**
	 * 文件夹拷贝
	 * @param src
	 * @param des
	 * @return
	 */
	public static void fileDirCopy(String src, String des) {  
        File file1 = new File(src);  
        File file2 = new File(des);
        
        try {
        	File[] fs = file1.listFiles();  
            if(!file2.exists()){  
                file2.mkdirs();  
            }  
            
            for (File f : fs) {  
            	if(f.isFile()){  
            		//调用文件拷贝的方法  
            		fileCopy(f.getPath(), des + "/" + f.getName());
                }else if(f.isDirectory()){  
                	fileDirCopy(f.getPath(), des + "/" + f.getName());  
                }  
            }  
		} catch (Exception e) {
			logger.error(e);
			throw new RuntimeException();
		}
    } 
	
	/**
	 * 报告复制
	 * @param src
	 * @param des
	 * @return
	 */
	public static void copyIspRep(String src, String des) {  
        File file1 = new File(src);  
        File file2 = new File(des);
        
        try {
        	File[] fs = file1.listFiles();  
            if(!file2.exists()){  
                file2.mkdirs();  
            }  
            
            for (File f : fs) {  
            	if(f.isFile()){  
            		if(f.getName().toString().indexOf(".xml") > 0 || f.getName().toString().indexOf(".rep") > 0 || f.getName().toString().indexOf("main.xls") > 0){
            			continue;
            		}else{
            			fileCopy(f.getPath(), des + "/" + f.getName());
            		}
                }else if(f.isDirectory()){  
                	copyIspRep(f.getPath(), des + "/" + f.getName());  
                }  
            }  
		} catch (Exception e) {
			logger.error(e);
			throw new RuntimeException();
		}
    }
	/**
	 * 判断路径或者文件是否存在
	 * @param path
	 * @return
	 */
	public static boolean isTruePath(String path) {
		boolean flag = false;
		File file = new File(path);
		if (file.exists()) {//判断文件目录的存在
			if(file.isDirectory()){
				flag=true;//只有是文件夹才算存在
			}

		} else {
			flag=false;
		}
		return flag;
	}

}